JavaScript Temporal.Duration: Ajaintervallide Aritmeetika ja Vormindamise Valdamine Globaalsetes Rakendustes

Aja haldamine tarkvaraarenduses on kurikuulsalt keeruline. Alates projektide ajakavade jälgimisest kontinentideüleselt kuni rahvusvaheliste videokonverentside planeerimiseni võivad ajaintervallide, ajavööndite ja suveaja nüansid kiiresti põhjustada peeneid, kuid kriitilisi vigu. Aastakümneid on JavaScripti arendajad maadelnud sisseehitatud Date-objektiga, mis on tööriist, mis, kuigi funktsionaalne lihtsate ajahetkede jaoks, jääb hätta täpse ajaintervallide aritmeetika ja robustse, globaalselt teadliku ajahaldusega.

Siin tuleb mängu JavaScript Temporal API – murranguline ettepanek, mis on loodud pakkuma kaasaegset, robustset ja kasutajasõbralikku API-d kuupäevade ja kellaaegadega töötamiseks JavaScriptis. Selle võimsate uute tüüpide hulgas paistab Temporal.Duration silma kui lõplik lahendus ajaintervallide käsitlemiseks. See artikkel süveneb Temporal.Duration'isse, uurides selle võimekust aritmeetikas, võrdlemises ja intelligentses vormindamises, tagades, et teie rakendused suudavad aega hallata globaalse täpsuse ja selgusega.

Ükskõik, kas ehitate globaalset logistikasüsteemi, finantskauplemisplatvormi või mitme ajavööndi sündmuste planeerijat, on Temporal.Duration'i mõistmine ülioluline ajaga seotud mitmetähenduslikkuse kõrvaldamiseks ja usaldusväärsete, rahvusvahelistatud kasutajakogemuste pakkumiseks.

JavaScripti Date-objekti puudused ajaintervallide käsitlemisel

Enne kui tähistame Temporal.Duration'i saabumist, on oluline mõista olemasoleva Date-objekti piiranguid, eriti ajaintervallidega tegelemisel. Date-objekt esindab kindlat ajahetke, mõõdetuna millisekundites alates Unixi epohhist (1. jaanuar 1970, UTC). Kuigi seda saab kasutada lihtsa aritmeetika tegemiseks, on sellel mitmeid olemuslikke vigu, mis muudavad selle robustseks kestuse haldamiseks sobimatuks:

• Muutlikkus: Date-objektid on muutlikud. Iga operatsioon Date-objektiga muudab selle sisemist olekut, mis võib põhjustada ootamatuid kõrvalmõjusid ja raskesti jälgitavaid vigu, eriti keerukates rakendustes või samaaegsetes keskkondades.

              const d = new Date('2023-01-15T10:00:00Z');
  const d2 = d; // d2 viitab nüüd samale objektile kui d
  d.setHours(d.getHours() + 1);
  
  console.log(d.toISOString());  // 2023-01-15T11:00:00.000Z
  console.log(d2.toISOString()); // 2023-01-15T11:00:00.000Z (ka d2 muutus!)
  
              
  
                
                  Copy
                
              
            

• Kestuse kontseptsiooni puudumine: Date-objektil puudub otsene "kestuse" või "perioodi" mõiste. Kahe kuupäeva vahe arvutamine annab tulemuseks millisekundite arvu, mis tuleb seejärel käsitsi teisendada aastateks, kuudeks, päevadeks jne. See käsitsi teisendamine on vigadele altis, eriti kui tegemist on erineva pikkusega kuude või liigaastatega.

              const date1 = new Date('2023-01-01T00:00:00Z');
  const date2 = new Date('2023-03-01T00:00:00Z');
  
  const diffMs = date2.getTime() - date1.getTime();
  
  // Mitu kuud see on? Aga liigaastad?
  // (diffMs / (1000 * 60 * 60 * 24 * 30)) on parimal juhul ligikaudne.
  console.log(`Difference in milliseconds: ${diffMs}`);
  console.log(`Approximate days: ${diffMs / (1000 * 60 * 60 * 24)}`); // Töötab päevade puhul, kuid pole kuude/aastate jaoks robustne
  
              
  
                
                  Copy
                
              
            

• Ajavööndi mitmetähenduslikkus: Date-objektid ajavad sageli segi kohaliku aja ja UTC. Kuigi need salvestavad sisemiselt UTC millisekundeid, töötavad nende meetodid vaikimisi sageli süsteemi kohalikus ajavööndis, mis põhjustab segadust ja ebajärjekindlust hajutatud süsteemide või rahvusvaheliste kasutajatega töötamisel.
• Suveaja (DST) väljakutsed: Suveajale üleminekud võivad põhjustada päevade pikkuseks 23 või 25 tundi. Lihtne aritmeetika (nt 24 tunni lisamine kuupäevale) ei pruugi alati anda tulemuseks järgmist kalendripäeva, mis viib valede arvutusteni, kui "päeva" eeldatakse olevat fikseeritud 24-tunnine periood.

Need piirangud on ajalooliselt sundinud arendajaid toetuma kolmandate osapoolte teekidele nagu Moment.js või date-fns või kirjutama keerulist, vigadele altist kohandatud koodi ajaintervallide korrektseks käsitlemiseks. Temporal eesmärk on tuua need võimalused JavaScripti sisse.

Tutvustame JavaScript Temporali: Kaasaegne lähenemine ajale

Temporal API on põhjalik, uus globaalne objekt JavaScriptis, mis on loodud olema kaasaegne asendus vanale Date-objektile. Selle põhiprintsiibid on muutumatus, selgesõnaline ajavööndite käsitlemine ja selge ülesannete eraldamine erinevate ajakontseptsioonide vahel. Temporal tutvustab mitmeid uusi klasse, millest igaüks esindab aja erinevat aspekti:

• Temporal.Instant: Spetsiifiline, ühemõtteline ajahetk, mis ei sõltu ühestki kalendrist ega ajavööndist (sarnane Unixi ajatempliga, kuid nanosekundi täpsusega).
• Temporal.ZonedDateTime: Konkreetne ajahetk kindlas kalendris ja ajavööndis. See on kasutaja jaoks kõige täielikum konkreetse kuupäeva ja kellaaja esitus.
• Temporal.PlainDate: Kalendrikuupäev (aasta, kuu, päev) ilma kellaaja või ajavööndita.
• Temporal.PlainTime: Kellaaeg (tund, minut, sekund jne) ilma kuupäeva või ajavööndita.
• Temporal.PlainDateTime: Kalendrikuupäev ja kellaaeg koos, ilma ajavööndita.
• Temporal.PlainYearMonth: Konkreetne aasta ja kuu kalendrisüsteemis.
• Temporal.PlainMonthDay: Konkreetne kuu ja päev kalendrisüsteemis.
• Temporal.Duration: Märgiga ajapikkus, näiteks "5 tundi ja 30 minutit" või "2 päeva". See on meie juhendi fookuses.

Kõik Temporali objektid on muutumatud, mis tähendab, et operatsioonid nagu aja lisamine või lahutamine loovad uusi objekte, mitte ei muuda olemasolevaid, parandades ettearvatavust ja vähendades vigu.

Temporal.Duration'i mõistmine

Temporal.Duration esindab ajapikkust. Oluline on see, et see on sõltumatu konkreetsest algus- või lõpp-punktist. See on lihtsalt "kui palju aega" möödus või möödub. See võib koosneda aastatest, kuudest, nädalatest, päevadest, tundidest, minutitest, sekunditest, millisekunditest, mikrosekunditest ja nanosekunditest. Iga komponent on täisarv ja võib olla positiivne või negatiivne.

Näiteks "2 tundi ja 30 minutit" on kestus. "Periood 1. jaanuarist 1. märtsini" on kestus kahe konkreetse punkti vahel, mida saab *esitada* Temporal.Duration'iga, kuid Duration ise on lihtsalt intervall.

Kestuse loomine

Temporal.Duration-objektide loomiseks on mitu lihtsat viisi:

1. Konstruktori kasutamine

Konstruktor võimaldab teil iga komponendi otse määrata. Pange tähele, et argumendid on järjestatud suurimast ühikust (aastad) väikseimani (nanosekundid).

            // new Temporal.Duration(aastad, kuud, nädalad, päevad, tunnid, minutid, sekundid, millisekundid, mikrosekundid, nanosekundid)

// Kestus 2 tundi ja 30 minutit
const duration1 = new Temporal.Duration(0, 0, 0, 0, 2, 30, 0, 0, 0, 0);
console.log(duration1.toString()); // P2H30M

// Kestus 1 aasta, 2 kuud, 3 päeva
const duration2 = new Temporal.Duration(1, 2, 0, 3);
console.log(duration2.toString()); // P1Y2M3D

// Kestus -5 päeva
const duration3 = new Temporal.Duration(0, 0, 0, -5);
console.log(duration3.toString()); // P-5D

            

              
                Copy
              
            
          

2. Temporal.Duration.from() kasutamine objektiga

See on sageli kõige loetavam viis kestuste loomiseks, võimaldades teil määrata ainult need komponendid, mida vajate.

            // Kestus 1,5 tundi
const halfHourDuration = Temporal.Duration.from({ hours: 1, minutes: 30 });
console.log(halfHourDuration.toString()); // P1H30M

// Kestus 7 päeva (1 nädal)
const oneWeekDuration = Temporal.Duration.from({ days: 7 });
console.log(oneWeekDuration.toString());  // P7D

// Kestus murdosa sekunditega (nt 2,5 sekundit)
const twoPointFiveSeconds = Temporal.Duration.from({ seconds: 2, milliseconds: 500 });
console.log(twoPointFiveSeconds.toString()); // PT2.5S

// Negatiivne kestus
const negativeDuration = Temporal.Duration.from({ minutes: -45 });
console.log(negativeDuration.toString()); // PT-45M

            

              
                Copy
              
            
          

3. Temporal.Duration.from() kasutamine ISO 8601 stringiga

Temporal kasutab ISO 8601 kestuse vormingut, mis on standard kestuste esitamiseks. See on suurepärane kestuste parsimiseks välistest andmeallikatest.

Vorming näeb tavaliselt välja selline: P[aastad]Y[kuud]M[nädalad]W[päevad]DT[tunnid]H[minutid]M[sekundid]S. T eraldab kuupäeva komponendid aja komponentidest.

            // 1 aasta, 2 kuud, 3 päeva
const isoDuration1 = Temporal.Duration.from('P1Y2M3D');
console.log(isoDuration1.toString()); // P1Y2M3D

// 4 tundi, 5 minutit, 6 sekundit
const isoDuration2 = Temporal.Duration.from('PT4H5M6S');
console.log(isoDuration2.toString()); // PT4H5M6S

// Kombineeritud kestus
const isoDuration3 = Temporal.Duration.from('P7DT12H30M');
console.log(isoDuration3.toString()); // P7DT12H30M

// Toetatud on ka murdosa sekundid
const isoDuration4 = Temporal.Duration.from('PT1.5S');
console.log(isoDuration4.toString()); // PT1.5S

            

              
                Copy
              
            
          

Aritmeetika tegemine kestustega

Temporal.Duration'i tõeline jõud avaldub selle aritmeetilistes võimetes. Saate kestusi liita, lahutada, korrutada ja jagada ning neid ka teistele Temporali kuupäeva-kellaaja tüüpidele liita/lahutada. Kõik operatsioonid tagastavad muutumatuse tõttu uued Temporal.Duration-objektid.

Kestuste liitmine

Meetod add() ühendab kaks kestust.

            const sprintDuration = Temporal.Duration.from({ weeks: 2 });
const bufferDuration = Temporal.Duration.from({ days: 3 });

const totalProjectTime = sprintDuration.add(bufferDuration);
console.log(totalProjectTime.toString()); // P2W3D (või P17D, kui hiljem normaliseerida)

// Negatiivse kestuse lisamine on samaväärne lahutamisega
const result = Temporal.Duration.from({ hours: 5 }).add({ hours: -2 });
console.log(result.toString()); // PT3H

            

              
                Copy
              
            
          

Samuti saate lisada kestuse mis tahes Temporali kuupäeva/kellaaja objektile. Siin toimub maagia, kuna Temporal käsitleb ajavööndi nihkeid ja suveaja üleminekuid asjakohaselt.

            const projectStart = Temporal.PlainDateTime.from('2023-10-26T09:00:00');
const projectDuration = Temporal.Duration.from({ days: 10, hours: 4 });

const projectEnd = projectStart.add(projectDuration);
console.log(projectEnd.toString()); // 2023-11-05T13:00:00

// ZonedDateTime'iga rakendatakse ajavööndi reegleid õigesti
const meetingStartUTC = Temporal.ZonedDateTime.from('2024-03-09T14:00:00[UTC]');
const meetingDuration = Temporal.Duration.from({ hours: 1, minutes: 45 });

const meetingEndUTC = meetingStartUTC.add(meetingDuration);
console.log(meetingEndUTC.toString()); // 2024-03-09T15:45:00+00:00[UTC]

// Näide suveaja piiri ületamisest (eeldades, et 'Europe/Berlin' nihkub kell 03:00 31.03.2024)
const springForwardStart = Temporal.ZonedDateTime.from('2024-03-30T22:00:00[Europe/Berlin]');
const twentyFourHours = Temporal.Duration.from({ hours: 24 });

const nextDay = springForwardStart.add(twentyFourHours); // Lisab 24 tegelikku tundi
console.log(springForwardStart.toString()); // 2024-03-30T22:00:00+01:00[Europe/Berlin]
console.log(nextDay.toString());          // 2024-03-31T23:00:00+02:00[Europe/Berlin] (Kohalik aeg jättis ühe tunni vahele)

            

              
                Copy
              
            
          

Pange tähele, kuidas 24 tunni lisamine ajale 2024-03-30T22:00:00 Berliinis (mis on UTC+1) annab tulemuseks 2024-03-31T23:00:00 (nüüd UTC+2). Kell liikus ühe tunni võrra edasi, seega on kellaaeg seinal üks tund hilisem võrreldes algse kellaajaga. See demonstreerib täpselt Temporali ajavööndi ja suveaja teadlikkust aritmeetika tegemisel `ZonedDateTime`'iga.

Kestuste lahutamine

Meetod subtract() töötab sarnaselt add()-ga, kuid see eemaldab aega.

            const deadlineDuration = Temporal.Duration.from({ days: 30 });
const gracePeriod = Temporal.Duration.from({ days: 5 });

const effectiveDeadline = deadlineDuration.subtract(gracePeriod);
console.log(effectiveDeadline.toString()); // P25D

const taskEnd = Temporal.PlainDateTime.from('2023-12-01T17:00:00');
const taskDuration = Temporal.Duration.from({ hours: 8, minutes: 30 });

const taskStart = taskEnd.subtract(taskDuration);
console.log(taskStart.toString()); // 2023-12-01T08:30:00

            

              
                Copy
              
            
          

Kestuste korrutamine ja jagamine

Meetodid multiply() ja divide() skaleerivad kestuse komponente antud teguriga. See on kasulik stsenaariumide puhul, nagu näiteks ülesande mitme iteratsiooni koguaja arvutamine.

            const trainingSession = Temporal.Duration.from({ minutes: 45 });
const weeklyTraining = trainingSession.multiply(5); // Viis seanssi nädalas
console.log(weeklyTraining.toString()); // PT225M

const totalProjectHours = Temporal.Duration.from({ hours: 160 });
const teamMembers = 4;

const hoursPerMember = totalProjectHours.divide(teamMembers);
console.log(hoursPerMember.toString()); // PT40H

            

              
                Copy
              
            
          

Kestuste eitamine

Meetod negate() pöörab kestuse kõigi komponentide märgi vastupidiseks. Positiivne kestus muutub negatiivseks ja vastupidi.

            const delayDuration = Temporal.Duration.from({ hours: 3 });
const advanceDuration = delayDuration.negate();

console.log(delayDuration.toString());   // PT3H
console.log(advanceDuration.toString()); // PT-3H

            

              
                Copy
              
            
          

Kestuste absoluutväärtus

Meetod abs() tagastab uue Temporal.Duration'i, mille kõik komponendid on positiivsed, andes teile efektiivselt kestuse suuruse, sõltumata selle märgist.

            const negativeDelay = Temporal.Duration.from({ minutes: -60 });
const positiveDuration = negativeDelay.abs();

console.log(negativeDelay.toString());  // PT-60M
console.log(positiveDuration.toString()); // PT60M

            

              
                Copy
              
            
          

Kestuste võrdlemine ja normaliseerimine

Kestuste võrdlemine võib olla keeruline, eriti kui tegemist on erinevate ühikutega (nt kas 1 kuu on võrdne 30 päevaga?). Temporal pakub tööriistu nii võrdlemiseks kui ka normaliseerimiseks, et nende keerukustega toime tulla.

Kestuste võrdlemine compare()-ga

Staatiline meetod Temporal.Duration.compare(duration1, duration2, options) tagastab:

• -1, kui duration1 on väiksem kui duration2
• 0, kui duration1 on võrdne duration2-ga
• 1, kui duration1 on suurem kui duration2

Oluline on see, et kui võrrelda kestusi, mis sisaldavad muutuva pikkusega ühikuid nagu aastad, kuud või nädalad, peate sageli pakkuma relativeTo valiku. See parameeter on `Temporal.ZonedDateTime` või `Temporal.PlainDateTime` objekt, mis annab konteksti nende ühikute tõlgendamiseks (nt mitu päeva on konkreetses kuus või aastas).

            const oneHour = Temporal.Duration.from({ hours: 1 });
const sixtyMinutes = Temporal.Duration.from({ minutes: 60 });

console.log(Temporal.Duration.compare(oneHour, sixtyMinutes)); // 0 (Need on samaväärsed)

const oneMonth = Temporal.Duration.from({ months: 1 });
const thirtyDays = Temporal.Duration.from({ days: 30 });

// Ilma relativeTo-ta on kuu/aasta võrdlused keerulised
console.log(Temporal.Duration.compare(oneMonth, thirtyDays)); // 0 (Temporal teeb ilma kontekstita mõistliku oletuse, sageli keskmise põhjal)

// Koos relativeTo-ga on võrdlus täpne, põhinedes konteksti kalendrile
const startOfJanuary = Temporal.PlainDate.from('2023-01-01');
const endOfFebruaryLeap = Temporal.PlainDate.from('2024-02-01'); // Liigaasta

// Jaanuaris 2023 on 1 kuu 31 päeva
const comparisonJan = Temporal.Duration.compare(oneMonth, thirtyDays, { relativeTo: startOfJanuary });
console.log(`1 kuu vs 30 päeva jaanuaris 2023: ${comparisonJan}`); // 1 (1 kuu > 30 päeva)

// Veebruaris 2024 (liigaasta) on 1 kuu 29 päeva
const comparisonFeb = Temporal.Duration.compare(oneMonth, thirtyDays, { relativeTo: endOfFebruaryLeap });
console.log(`1 kuu vs 30 päeva veebruaris 2024: ${comparisonFeb}`); // -1 (1 kuu < 30 päeva)

            

              
                Copy
              
            
          

Kestuste normaliseerimine normalize() ja round()-ga

Kestusi saab esitada mitmel viisil (nt 90 minutit või 1 tund ja 30 minutit). Normaliseerimine ja ümardamine aitavad neid esitusi järjepidevuse ja kuvamise jaoks standardiseerida.

normalize()

Meetod normalize() lihtsustab kestuse komponente, kus see on võimalik (nt 60 minutit muutub 1 tunniks, 24 tundi muutub 1 päevaks, eeldusel et `relativeTo` kontekst lubab, kui kuud/aastad on kaasatud).

            const longMinutes = Temporal.Duration.from({ minutes: 90 });
console.log(longMinutes.toString()); // PT90M
console.log(longMinutes.normalize().toString()); // PT1H30M

const multipleDays = Temporal.Duration.from({ hours: 48 });
console.log(multipleDays.toString()); // PT48H
console.log(multipleDays.normalize().toString()); // P2D

            

              
                Copy
              
            
          

round()

Meetod round() on võimsam kestuste teisendamiseks ja ümardamiseks kindlatele ühikutele. See võtab valikute objekti, mis sisaldab:

• largestUnit: Suurim ühik, mis väljundisse lisatakse (nt 'years', 'days', 'hours').
• smallestUnit: Väikseim ühik, mis väljundisse lisatakse (nt 'minutes', 'seconds', 'milliseconds').
• roundingIncrement: Täisarv, millega väikseimat ühikut ümardada (nt 5 lähima 5 minuti ümardamiseks).
• roundingMode: Kuidas käsitleda viike (nt 'halfExpand', 'trunc', 'ceil', 'floor').
• relativeTo: Nõutav aastate, kuude või nädalatega kestuste ümardamiseks.

            const complexDuration = Temporal.Duration.from({ hours: 2, minutes: 45, seconds: 30 });

// Ümarda lähima tunnini
const roundedToHours = complexDuration.round({ smallestUnit: 'hour' });
console.log(roundedToHours.toString()); // PT3H

// Ümarda lähima 30 minutini, säilitades tunnid
const roundedTo30Minutes = complexDuration.round({
  largestUnit: 'hour',
  smallestUnit: 'minute',
  roundingIncrement: 30
});
console.log(roundedTo30Minutes.toString()); // PT3H

const preciseDuration = Temporal.Duration.from({ minutes: 123, seconds: 45 });

// Kuva tundide ja minutitena
const formattedDuration = preciseDuration.round({ largestUnit: 'hour', smallestUnit: 'minute' });
console.log(formattedDuration.toString()); // PT2H4M

// Kuude/aastatega ümardamine nõuab relativeTo
const longTermDuration = Temporal.Duration.from({ months: 1, days: 10 });
const referenceDate = Temporal.PlainDate.from('2023-01-15');

// Ümarda kuudeni, suhtes kuupäevaga
const roundedToMonths = longTermDuration.round({ largestUnit: 'month', smallestUnit: 'month', relativeTo: referenceDate });
console.log(roundedToMonths.toString()); // P1M

            

              
                Copy
              
            
          

Kestuste arvutamine Temporali objektide vahel

Üks sagedasemaid kestuste kasutusviise on ajaintervalli arvutamine kahe konkreetse ajahetke vahel. Temporal pakub selleks oma kuupäeva-kellaaja objektidel meetodeid until() ja since().

Meetod until()

Meetod until() arvutab kestuse vastuvõtja objektist argumendi objektini. See on alguspunkti kaasa arvatav ja lõpp-punkti välistav. See võtab sarnaselt round()-ga valikute objekti soovitud ühikute ja ümardamiskäitumise määramiseks.

            const startDate = Temporal.PlainDate.from('2023-01-01');
const endDate = Temporal.PlainDate.from('2023-03-15');

// Kestus suurimates võimalikes ühikutes (kuud, seejärel päevad)
const projectLength = startDate.until(endDate);
console.log(projectLength.toString()); // P2M14D

// Kestus puhtalt päevades
const totalDays = startDate.until(endDate, { largestUnit: 'day' });
console.log(totalDays.toString()); // P73D

// Kestus kahe konkreetse aja vahel, arvestades ajavööndeid
const meetingStart = Temporal.ZonedDateTime.from('2024-07-20T10:00:00[America/New_York]');
const meetingEnd = Temporal.ZonedDateTime.from('2024-07-20T11:30:00[America/New_York]');

const elapsedMeetingTime = meetingStart.until(meetingEnd, { largestUnit: 'hour', smallestUnit: 'minute' });
console.log(elapsedMeetingTime.toString()); // PT1H30M

// Ajavöönditeülene kestus (NYC-st Londonisse)
const nyStartTime = Temporal.ZonedDateTime.from('2024-08-01T09:00:00[America/New_York]');
const londonEndTime = Temporal.ZonedDateTime.from('2024-08-01T17:00:00[Europe/London]');

const travelDuration = nyStartTime.until(londonEndTime);
console.log(travelDuration.toString()); // PT13H (Tegelik möödunud aeg, mitte kellaaja erinevus)

            

              
                Copy
              
            
          

Viimane näide on eriti tähelepanuväärne. Kuigi New York on Londonist 5 tundi taga ja kellaajad seinal on 9 AM ja 5 PM samal päeval, arvutab meetod until() õigesti tegeliku möödunud aja, mis on 13 tundi. See on sellepärast, et ZonedDateTime käsitleb ajavööndi erinevust implitsiitselt.

Meetod since()

Meetod since() on until()-i vastand. See arvutab kestuse argumendi objektist vastuvõtja objektini, mille tulemuseks on negatiivne kestus, kui argument on tulevikus võrreldes vastuvõtjaga.

            const currentDateTime = Temporal.ZonedDateTime.from('2024-06-15T12:00:00[Europe/Paris]');
const historicEvent = Temporal.ZonedDateTime.from('2024-01-01T00:00:00[Europe/Paris]');

const timeSinceEvent = currentDateTime.since(historicEvent, { largestUnit: 'month', smallestUnit: 'day' });
console.log(timeSinceEvent.toString()); // P5M14D

const futureDate = Temporal.PlainDate.from('2025-01-01');
const pastDate = Temporal.PlainDate.from('2024-01-01');

const durationFromFuture = pastDate.since(futureDate);
console.log(durationFromFuture.toString()); // P-1Y

            

              
                Copy
              
            
          

Erinevate ühikute ja ümardamise käsitlemine arvutatud kestuste puhul

Kestuste arvutamisel on sageli vaja määrata `largestUnit` ja `smallestUnit`, et saada inimloetav esitus, eriti vanuse, möödunud aja või loendurite puhul.

            const birthDate = Temporal.PlainDate.from('1990-07-15');
const today = Temporal.PlainDate.from('2024-06-15');

// Arvuta vanus aastates, kuudes ja päevades
const age = birthDate.until(today, { largestUnit: 'year', smallestUnit: 'day' });
console.log(`Vanus: ${age.years} aastat, ${age.months} kuud, ${age.days} päeva`); // Vanus: 33 aastat, 11 kuud, 0 päeva

// Arvuta ülesande järelejäänud aeg tundides ja minutites
const now = Temporal.Instant.fromEpochSeconds(Date.now() / 1000);
const deadline = Temporal.Instant.from('2024-07-01T09:00:00Z');

const timeLeft = now.until(deadline, { largestUnit: 'hour', smallestUnit: 'minute', roundingMode: 'ceil' });
console.log(`Aega jäänud: ${timeLeft.hours} tundi ja ${timeLeft.minutes} minutit.`); // Näide: Aega jäänud: 355 tundi ja 38 minutit.

            

              
                Copy
              
            
          

Kestuste vormindamine globaalsele publikule

Kuigi Temporal.Duration pakub täpseid, programmilisi esitusi ajaintervallidest, ei ole sellel sisseehitatud toLocaleString() meetodit. See on taotluslik: kestused on abstraktsed ajapikkused ja nende kuvamine võib oluliselt varieeruda sõltuvalt kontekstist, lokaadist ja soovitud detailsuse tasemest. Teie kui arendaja vastutate kestuste esitamise eest kasutajasõbralikul ja globaalselt arusaadaval viisil.

ISO 8601 stringi esitus

Temporal.Duration-objekti vaikemeetod toString() tagastab selle ISO 8601 stringi esituse. See on suurepärane masinatevaheliseks suhtluseks, serialiseerimiseks ja salvestamiseks, kuid harva otse lõppkasutajatele kuvamiseks.

            const examDuration = Temporal.Duration.from({ hours: 2, minutes: 15 });
console.log(examDuration.toString()); // PT2H15M

const holidayDuration = Temporal.Duration.from({ weeks: 2, days: 3 });
console.log(holidayDuration.toString()); // P2W3D

            

              
                Copy
              
            
          

Käsitsi vormindamine loetavuse ja rahvusvahelistamise jaoks

Kasutajale suunatud kuvamiseks eraldate tavaliselt kestuse komponendid ja vormindate need stringi interpoleerimise ja JavaScripti Intl API abil.

Siin on kohandatud funktsiooni näide, mis vormindab kestuse:

            function formatDurationToHumanReadable(duration, locale = 'et-EE') {
  const parts = [];

  // Kasutades Intl.NumberFormat'i lokaaditeadlikuks numbrite vormindamiseks
  const numberFormatter = new Intl.NumberFormat(locale);

  if (duration.years !== 0) {
    parts.push(numberFormatter.format(duration.years) + ' ' + (duration.years === 1 ? 'aasta' : 'aastat'));
  }
  if (duration.months !== 0) {
    parts.push(numberFormatter.format(duration.months) + ' ' + (duration.months === 1 ? 'kuu' : 'kuud'));
  }
  if (duration.weeks !== 0) {
    parts.push(numberFormatter.format(duration.weeks) + ' ' + (duration.weeks === 1 ? 'nädal' : 'nädalat'));
  }
  if (duration.days !== 0) {
    parts.push(numberFormatter.format(duration.days) + ' ' + (duration.days === 1 ? 'päev' : 'päeva'));
  }
  if (duration.hours !== 0) {
    parts.push(numberFormatter.format(duration.hours) + ' ' + (duration.hours === 1 ? 'tund' : 'tundi'));
  }
  if (duration.minutes !== 0) {
    parts.push(numberFormatter.format(duration.minutes) + ' ' + (duration.minutes === 1 ? 'minut' : 'minutit'));
  }
  if (duration.seconds !== 0) {
    // Ümarda sekundid kuvamiseks, kui neil on murdosa
    const roundedSeconds = numberFormatter.format(duration.seconds.toFixed(0)); // Või toFixed(1) ühe komakoha jaoks
    parts.push(roundedSeconds + ' ' + (duration.seconds === 1 ? 'sekund' : 'sekundit'));
  }

  if (parts.length === 0) {
    // Käsitse juhtumeid, kus kestus on null või väga väike (nt ainult nanosekundid)
    if (duration.milliseconds !== 0 || duration.microseconds !== 0 || duration.nanoseconds !== 0) {
        const totalMs = duration.milliseconds + duration.microseconds / 1000 + duration.nanoseconds / 1_000_000;
        return numberFormatter.format(totalMs.toFixed(2)) + ' millisekundit';
    }
    return '0 sekundit';
  }

  // Ühenda osad komadega ja 'ja'-ga viimase osa jaoks (eestikeelne ühendamine)
  if (parts.length > 1) {
    const lastPart = parts.pop();
    return parts.join(', ') + ' ja ' + lastPart;
  } else {
    return parts[0];
  }
}

const tripDuration = Temporal.Duration.from({ days: 3, hours: 10, minutes: 45 });
console.log(formatDurationToHumanReadable(tripDuration, 'et-EE')); // 3 päeva, 10 tundi ja 45 minutit

const meetingReminder = Temporal.Duration.from({ minutes: 5 });
console.log(formatDurationToHumanReadable(meetingReminder, 'et-EE')); // 5 minutit

const microDuration = Temporal.Duration.from({ nanoseconds: 1234567 });
console.log(formatDurationToHumanReadable(microDuration, 'et-EE')); // 1,23 millisekundit

            

              
                Copy
              
            
          

Keerulisema mitmuse ja lokaliseeritud loendivorminduse jaoks võiksite seda kombineerida Intl.RelativeTimeFormat'iga või keerukamate stringimallide teekidega. Võti on eraldada kestuse arvutamine (mida teeb Temporal) selle esitusest (mida teeb teie vormindusloogika ja Intl).

Intl.DurationFormat'i kasutamine (Tulevik/Ettepanek)

Käimas on TC39 ettepanek Intl.DurationFormat'i kohta, mille eesmärk on pakkuda natiivset, lokaaditeadlikku viisi kestuste vormindamiseks. Kui see standardiseeritakse ja rakendatakse, lihtsustaks see oluliselt ülaltoodud käsitsi vormindamist, pakkudes robustset lahendust rahvusvahelistamiseks otse JavaScripti ökosüsteemis.

See töötaks tõenäoliselt sarnaselt teiste Intl-objektidega:

            // See on hüpoteetiline ja põhineb ettepaneku praegusel seisul
// Kontrollige brauseri ühilduvust enne tootmises kasutamist

/*
const duration = Temporal.Duration.from({ days: 1, hours: 2, minutes: 30 });

const formatter = new Intl.DurationFormat('et-EE', {
  style: 'long',
  years: 'long',
  days: 'long',
  hours: 'long',
  minutes: 'long',
});

console.log(formatter.format(duration)); // "1 päev, 2 tundi, 30 minutit"

const shortFormatter = new Intl.DurationFormat('et-EE', { style: 'short', hours: 'numeric', minutes: 'numeric' });
console.log(shortFormatter.format(duration)); // "1 p, 2 t, 30 min"
*/

            

              
                Copy
              
            
          

Kuigi see pole veel kõigis keskkondades saadaval, hoidke sellel ettepanekul silm peal, sest see tõotab olla tulevikus lõplik lahendus globaalseks kestuste vormindamiseks.

Praktilised kasutusjuhud ja globaalsed kaalutlused

Temporal.Duration ei ole lihtsalt akadeemiline parendus; see lahendab reaalseid probleeme rakendustes, mis tegutsevad erinevates ajavööndites ja kultuurides.

1. Planeerimine ja sündmuste haldamine

Rahvusvahelisi sündmusi, konverentse või kohtumisi haldavate platvormide jaoks on sündmuste kestuste, sündmuseni jäänud aja või pausi pikkuse arvutamine kriitilise tähtsusega. Temporal.Duration tagab, et need arvutused on täpsed, olenemata kasutaja asukohast või kohalikest ajavööndi reeglitest.

            // Arvuta globaalse veebiseminari järelejäänud aeg
const now = Temporal.ZonedDateTime.from('2024-07-25T10:00:00[Europe/London]'); // Näitlik praegune aeg
const webinarStart = Temporal.ZonedDateTime.from('2024-07-26T14:30:00[Asia/Tokyo]');

const timeUntilWebinar = now.until(webinarStart, {
  largestUnit: 'hour',
  smallestUnit: 'minute',
  roundingMode: 'ceil' // Ümarda ülespoole, et kasutajad sellest ilma ei jääks
});

console.log(`Veebiseminar algab ${timeUntilWebinar.hours} tunni ja ${timeUntilWebinar.minutes} minuti pärast.`);
// Väljund on täpne, põhinedes tegelikul möödunud ajal nende kahe ZonedDateTime'i vahel.

            

              
                Copy
              
            
          

2. Jõudlusmõõdikud ja logimine

Operatsioonide täitmise aja, API vastuseaegade või pakett-tööde kestuste mõõtmine nõuab suurt täpsust. Temporal.Duration, eriti kombineerituna Temporal.Instant'iga (mis pakub nanosekundi täpsust), on selleks ideaalne.

            const startTime = Temporal.Instant.now();

// Simuleeri keerulist operatsiooni
for (let i = 0; i < 1_000_000; i++) { Math.sqrt(i); }

const endTime = Temporal.Instant.now();

const executionDuration = startTime.until(endTime);

// Vorminda sekunditeks koos millisekunditega kuvamiseks
const formattedExecution = executionDuration.round({ smallestUnit: 'millisecond', largestUnit: 'second' });

console.log(`Operatsioon võttis aega ${formattedExecution.seconds}.${String(formattedExecution.milliseconds).padStart(3, '0')} sekundit.`);

            

              
                Copy
              
            
          

3. Finantsarvutused

Finantsvaldkonnas on täpsed ajaintervallid intresside, laenutingimuste või investeerimisperioodide arvutamisel ülimalt tähtsad. Päevade, kuude või aastate täpne arv perioodis peab olema täpne, eriti kui tegemist on liigaastate või konkreetsete kuupikkustega.

            const loanStartDate = Temporal.PlainDate.from('2023-04-01');
const loanEndDate = Temporal.PlainDate.from('2028-03-31');

const loanTerm = loanStartDate.until(loanEndDate, { largestUnit: 'year', smallestUnit: 'month' });
console.log(`Laenuperiood: ${loanTerm.years} aastat ja ${loanTerm.months} kuud.`); // 4 aastat ja 11 kuud

            

              
                Copy
              
            
          

4. Rahvusvahelistamise väljakutsed uuesti vaadelduna

• Ajavööndid ja suveaeg: Temporal.Duration ise on ajavööndist sõltumatu; see esindab fikseeritud ajapikkust. Kuid kui lisate või lahutate Duration'i ZonedDateTime'ist, rakendab Temporal korrektselt ajavööndi reegleid, sealhulgas suveaja nihkeid. See tagab, et "24-tunnine kestus" liigutab ZonedDateTime'i tõepoolest 24 tegeliku tunni võrra edasi, isegi kui see tähendab suveaja piiri ületamist, mis muudab *kellaaja* seinal lühemaks või pikemaks. See järjepidevus on suur võit `Date`'i üle.
• Kultuurilised erinevused: Erinevad kultuurid väljendavad kestusi erinevalt. Kuigi Temporal.Duration pakub tooreid komponente (aastad, kuud, päevad jne), on teie vastutus kasutada `Intl` API-sid või kohandatud loogikat, et esitada neid viisil, mis on kasutaja lokaadile omane. Näiteks võivad mõned kultuurid väljendada "1 tund ja 30 minutit" kui "90 minutit" või kasutada erinevaid mitmuse reegleid.
• Kalendrisüsteemid: Temporal toetab ka erinevaid kalendrisüsteeme (nt Jaapani, Pärsia, Islami kalendrid). Kuigi Duration ise on kalendrist sõltumatu, austab aritmeetika kalendriteadlike tüüpidega nagu PlainDate või ZonedDateTime suheldes konkreetse kalendri reegleid (nt päevade arv kuus, liigaasta reeglid selles kalendris). See on ülioluline globaalsete rakenduste jaoks, mis võivad vajada kuupäevade kuvamist mitte-Gregoriuse kalendrites.

Temporali praegune staatus ja kasutuselevõtt

2023. aasta lõpu / 2024. aasta alguse seisuga on JavaScript Temporal API 3. etapi TC39 ettepanek. See tähendab, et spetsifikatsioon on suures osas stabiilne ning seda rakendatakse ja testitakse erinevates JavaScripti mootorites ja brauserites. Suured brauserid nagu Chrome, Firefox ja Safari töötavad aktiivselt Temporali rakendamise kallal, kusjuures eksperimentaalsed lipud või varajased versioonid on juba saadaval.

Kuigi see pole veel universaalselt saadaval ilma polüfillita, näitab selle edasijõudnud etapp, et see saab suure tõenäosusega JavaScripti standardseks osaks. Arendajad saavad täna hakata Temporaliga katsetama, kasutades polüfille või lubades oma brauseri arenduskeskkondades eksperimentaalseid funktsioone. Varajane kasutuselevõtt võimaldab teil eesrindlik olla, mõista selle eeliseid ja integreerida see oma projektidesse, kui brauseri tugi laieneb.

Selle lõpuks laialdane kasutuselevõtt vähendab oluliselt vajadust väliste kuupäeva/aja teekide järele, pakkudes robustset, natiivset lahendust JavaScripti ajahalduseks.

Parimad praktikad Temporal Durationi kasutamisel

Temporal.Duration'i eeliste maksimeerimiseks oma rakendustes kaaluge neid parimaid praktikaid:

• Eelistage Temporal.Duration.from(): Teadaolevatest komponentidest või ISO-stringidest kestuste loomisel on Temporal.Duration.from() objektiliteraaliga sageli loetavam ja vähem vigadele altis kui konstruktori positsioonilised argumendid.
• Kasutage relativeTo mitmetähenduslike võrdluste jaoks: Pakkuge alati relativeTo valikut, kui võrdlete või ümardate kestusi, mis sisaldavad aastaid, kuid või nädalaid. See tagab täpsed arvutused, pakkudes vajaliku kalendrikonteksti.
• Kasutage until() ja since(): Kahe konkreetse ajahetke vahelise intervalli arvutamiseks eelistage Temporali kuupäeva-kellaaja objektide meetodeid until() ja since(). Need käsitlevad korrektselt ajavööndite ja suveaja keerukusi.
• Normaliseerige ja ümardage kuvamiseks: Enne kestuste esitamist kasutajatele kaaluge normalize() ja eriti round() kasutamist, et teisendada kestus kõige sobivamatesse ja arusaadavamatesse ühikutesse (nt 90 minuti teisendamine "1 tunniks ja 30 minutiks").
• Eraldage sisemine esitus kuvamisest: Hoidke oma sisemised kestuse arvutused täpsed Temporal.Duration'iga. Teisendage ja vormindage kuvamiseks ainult kasutajaliidese renderdamisel, kasutades kohandatud vormindusfunktsioone ja Intl API-d globaalse täpsuse tagamiseks.
• Olge kursis: Hoidke silm peal Temporali API edusammudel ja brauseri ühilduvusel. Kuna see liigub täieliku standardiseerimise suunas, areneb ökosüsteem ja võivad tekkida uued tööriistad või parimad praktikad.
• Olge täpsusega teadlik: Kuigi Temporal toetab nanosekundi täpsust, kasutage ainult seda täpsust, mida tegelikult vajate. Suurem täpsus võib mõnikord muuta silumise raskemaks või põhjustada ootamatuid ümardamisi madalama täpsusega kuvaritele teisendamisel.

Kokkuvõte

Temporal.Duration'i kasutuselevõtt tähistab olulist hüpet edasi JavaScripti arendajatele, kes tegelevad ajaintervallide aritmeetikaga. Pakkudes muutumatut, selgesõnalist ja globaalselt teadlikku API-d, lahendab Temporal vana Date-objekti pikaajalised piirangud.

Nüüd saate enesekindlalt sooritada keerulisi ajaarvutusi, täpselt mõõta perioode ja esitada kestusi viisil, mis on nii täpne kui ka kultuuriliselt sobiv kasutajatele üle maailma. Ükskõik, kas arvutate tarkvara väljalasketsükli kestust, ülemaailmse toote turuletoomiseni jäänud aega või inimese täpset vanust, pakub Temporal.Duration teile tööriistu, mida vajate robustsete ja usaldusväärsete rakenduste loomiseks.

Võtke omaks Temporal.Duration ja muutke seda, kuidas te oma JavaScripti projektides aega haldate. JavaScripti kuupäevade ja kellaaegade käsitlemise tulevik on siin, lubades ettearvatavamat, võimsamat ja globaalselt ühilduvamat arenduskogemust.